.TITLE	TTCT
	.IDENT	/02.01/
;
; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; THIS  SOFTWARE  IS  FURNISHED  UNDER  A LICENSE AND MAY BE USED
; AND  COPIED  ONLY IN  ACCORDANCE WITH THE TERMS OF SUCH LICENSE
; AND WITH  THE INCLUSION  OF THE ABOVE  COPYRIGHT  NOTICE.  THIS
; SOFTWARE  OR ANY OTHER  COPIES  THEREOF, MAY NOT BE PROVIDED OR
; OTHERWISE MADE  AVAILABLE TO ANY OTHER PERSON.  NO TITLE TO AND
; OWNERSHIP OF THE SOFTWARE IS HEREBY TRANSFERED.
;
; THE INFORMATION  IN THIS DOCUMENT IS SUBJECT  TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT  BY  DIGITAL
; EQUIPMENT CORPORATION.
;
; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
; ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
;
;
;
; 3-JUL-82 TONY LEKAS
;
; MODIFICATIONS:
;
;      WMG029	2-MAR-83	WILLIAM M. GERACI
;		ADD ERROR PASSING CAPABILITY FOR TFW TO PASS
;		ERROR STATUS TO TTDRV (P/OS)
;
;	S. C. ADAMS	2-MAY-84	02.01
;		SA170 -- SUPPORT CHANGES TO STATUS BITS
;
;
;+
; CONTROLLER-DEPENDENT ROUTINES FOR CT VIDEO DISPLAY
;-
;

	.IF DF	B$$MAP

	.PSECT	MAP5
;
;+
; YCSTAX - START OUTPUT.
;
; INPUT:
;	REGISTERS R2-R5 STANDARD FOR CONTROLLER-DEPENDENT ROUTINE.
;
;	R2	PHYSICAL UNIT NUMBER * 2
;		(ONLY IF MULTIPLEXERS IN SYSTEM)
;	R3	CSR ADDRESS
;	R4	UCBX ADDRESS
;	R5	POINTER TO U.TSTA
;
;	U.TOP		BUFFER LIST POINTER
;	U.TOC		BYTE COUNT
;
;  NOTE:
;	THE VIDEO TASK SHOULD DECREMENT T.OREM AS DATA IS REMOVED
;	FROM THE BUFFERS.  THE COUNT IN THE SECOND STATUS WORD
;	THAT IS RETURNED TO THE USER IS THE ORIGINAL COUNT MINUS
;	T.OREM.
;
; Intermediate input and output buffer. - 
;
;        byte            contents
;        ------------------------------------
;        0-1             link to next buffer (0 if this is last)
;        2               logical buffer length
;        3               reserved
;        4-47            data
;
;
; NOTE:
;
;		THE OUTPUT TIMER IS BEING CLEARED BECAUSE
;		SOME OUTPUT TO THE VIDEO TASK, FOR EXAMPLE
;		GIDIS, MAY TAKE A LONG TIME.
;-
;

YCSTAX::CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING
	CLRB	U.TOTI(R4)		;CLEAR OUTPUT TIMER


; COMPUTE THE TOTAL TRANSFER SIZE

	MOV	U.TTOC(R4),T.OREM	;GET THE NUMBER OF BYTES IN THE XFR
					;THAT ARE NOT CURRENTLY BUFFERED
	ADD	U.TOC(R4),T.OREM	;ADD IN THE AMOUNT FOR THE FIRST
					;BUFFER OR FOR THE ECHO BUFFER
	TST	U.TCO(R4)		;BUFFER CHAIN USED?
	BEQ	10$			;IF EQ NO - COPY THE DATA
	MOV	U.TOP(R4),T.OPKP	;MOV THE BUFFER LIST ADDRESS FOR TFW

; NOW WE ADD IN THE COUNTS FOR THE EXTRA BUFFERS IF ANY

; THIS CODE DEPENDS ON THE MAXIMUM BUFFER LENGTH
; BEING LESS THAN 128.

	MOV	T.OPKP,R1		;GET THE ADDRESS OF THE FIRST BUFFER
5$:	MOVB	U.TDYP(R4),3(R1)	;STORE THE DATA TYPE
	MOV	(R1),R1			;GET THE POINTER TO THE NEXT BUFFER
	BEQ	REQEST			;IF EQ NO MORE - REQUEST THE TASK
	MOVB	2(R1),R0		;GET THE BUFFER LENGTH
	ADD	R0,T.OREM		;ADD IT TO THE COUNT
	BR	5$			;TRY FOR SOME MORE

; COPY THE SINGLE BUFFER INTO A BUFFER IN TFWCOM

10$:	MOV	#T.TBUF,T.OPKP		;MOV THE BUFFER LIST ADDRESS FOR TFW
	MOV	U.TOC(R4),R1		;GET THE CHARACTER COUNT
	MOVB	R1,T.TBUF+2		;PUT THE LENGTH INTO THE BUFFER
	MOV	#T.TBUF+4,R0		;POINT TO DATA AREA OF THE TEMP BUFFER
	MOV	U.TOP+2(R4),R3		;GET THE SOURCE BUFFER ADDRESS
20$:	MOVB	(R3)+,(R0)+		;MOVE A BYTE
	SOB	R1,20$			;DO THEM ALL
	BR	REQEST			;REQUEST THE TASK

;
;+
; YCABOX - ABORT OUTPUT.
;
; INPUT:
;	REGISTERS R2-R5 STANDARD FOR CONTROLLER-DEPENDENT ROUTINE.
;
;  NOTE:
;	THE VIDEO TASK MUST NOT USE ANY CHARACTERS
;	FROM THE BUFFER AFTER TF.ABO HAS BEEN SET
;	BECAUSE THE BUFFER WILL HAVE BEEN DEALLOCATED.
;
;	GET THE CHARACTER(S) AND THEN TEST THE BIT.  IF IT
;	IS SET DO NOT USE THE CHARACTER(S)
;-
;

YCABOX::CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING
	BIS	#TF.ABO,T.FLAG		;SET THE ABORT BIT
	CLR	T.OPKP			;CLEAR THE BUFFER POINTER
	BR	REQEST			;AND REQUEST THE TASK

;
;+
; YCSTOX - STOP (SUSPEND) OUTPUT.
;
; INPUT:
;	REGISTERS R2-R5 STANDARD FOR CONTROLLER-DEPENDENT ROUTINE.
;-
;

YCSTOX::CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING
	BIS	#TF.SPN,T.FLAG		;SET THE SUSPEND BIT
	BR	REQEST			;AND REQUEST THE TASK


;
;+
; YCRESX - RESUME OUTPUT.
;
; INPUT:
;	REGISTERS R2-R5 STANDARD FOR CONTROLLER-DEPENDENT ROUTINE.
;-
;

YCRESX::CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING
	BIC	#TF.SPN,T.FLAG		;CLEAR THE SUSPEND BIT
	BR	REQEST			;AND REQUEST THE TASK


;
;+
; YCPWUP - POWER-UP.
;
; INPUT:
;	REGISTERS R2-R5 STANDARD FOR CONTROLLER-DEPENDENT ROUTINE.
;-
;

	.IF DF	R$$CON

YCCONL::
YCCPUP::RETURN				;ONLY INIT FOR UNIT ONLINE
YCUONL::
YCUPUP::

	.IFF

YCPWUP::

	.ENDC	;R$$CON

	CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING

	TST	#<TFWCOM&77>		;32 WORD ALIGNED?
	BEQ	5$			;IF EQ YES - OK
	CRASH				;OOOPS

5$:	MOV	#VT.NAM,R3		;GET THE ADDRESS OF THE TASKS NAME
	CALL	$SRSTD			;GET THE TASKS TCB ADDRESS
	BCC	10$			;BRANCH IF NO ERRORS
	CRASH				;TASK NOT INSTALLED
10$:	MOV	R0,VT.TCB		;SAVE THE TCB ADDRESS

	MOV	#<<TFWCOM-120000>/64.>,VT.APR  ;TFWCOM'S OFFSET IN TTDRV
	ADD	@#KISAR5,VT.APR		;COMPUTE TFWCOMS PHYSICAL ADDRESS
	MOV	#TFWPAR,R3		;GET THE ADDRESS OF TFWCOM'S NAME
	CALL	$SRNAM			;GET THE PARTITIONS PCB ADDRESS
	BCC	20$			;IF CC OK
	CRASH				;PARTITION NOT AROUND
20$:	MOV	VT.APR,P.REL(R2)	;FILL IN BASE ADDR IN 32. WORD BLOCKS
	MOV	#<<TFWEND-TFWCOM>/64.>,P.BLKS(R2)  ;AND THE LENGTH

	BIS	#TF.INT,T.FLAG		;SET THE INITIALIZE BIT

REQEST:	MOV	VT.TCB,R0		;SETTUP THE TASK'S TCB ADDRESS
	CALLR	$EXRQN			;REQUEST THE TASK

;
;+
; G$IN - DRIVER INPUT ROUTINE
;
; THIS ROUTINE IS CALLED IN SYSTEM STATE BY THE VIDEO TASK
; TO INFORM THE DRIVER THAT THERE IS INPUT WAITING IN THE
; INPUT BUFFER.
;
; REGISTERS MODIFIED:
;		ALL
;-
;

;
; DEFINE THE KEY MATRIX CODES FOR INTERRUPT AND DO HERE FOR NOW.
; THESE DEFINITIONS SHOULD BE PROVIDED BY THE TERMINAL TASK CODE
; SINCE THEY ARE "DEFINED" BY IT.
;

K.INT	=	144			;MATRIX CODE FOR INTERRUPT
K.DO	=	175			;MATRIX CODE FOR DO

G$IN::	MTPS	#TTPRI			;LOCK OUT TERMINAL INTERRUPTS
	CLR	R4			;;;INDICATE THAT THIS IS CONTROLLER 0
	TTSET$	YC			;;;CALL TTSET SETTUP FOR POSSIBLE FORK
	MOV	#.TTCT+U.TSTA,R5	;;;SETTUP FOR ICHAR1 CALL
	MOV	#T.INBF,R0		;;;GET THE BUFFER ADDRESS

					;;;ASSUME THE TYPE BYTE IS FIRST
	MOVB	(R0)+,R2		;;;GET THE DATA TYPE
	CMP	#T.RSDN,R2		;;;LEGAL DATA TYPE?
	BHIS	5$			;;;IF HIS YES - PROCESS THE INPUT
	CRASH				;;;BAD DATA TYPE
5$:	ASL	R2			;;;MAKE IT AN INDEX
	MOV	R2,DTYPE		;;;SAVE THE DATA TYPE INDEX

					;;;ASSUME THAT THE LENGTH IS NEXT
10$:	MOVB	(R0)+,R1		;;;GET THE CHARACTER COUNT
	BEQ	50$			;;;IF EQ NO CHARACTERS - EXIT

	.IF DF	T$$IDO

	TST	R2			;;;DATA TYPE ZERO?
	BNE	15$			;;;NE NO - CAN'T BE INTERRUPT OR DO
	CMPB	#K.INT,(R0)		;;;INTERRUPT KEY?
	BEQ	100$			;;;EQ YES - GO PROCESS IT
	CMPB	#K.DO,(R0)		;;;DO KEY?
	BEQ	100$			;;;EQ YES - GO PROCESS IT
	BR	15$			;;;AND GO PROCESS THE CHARACTER
;
; WE HAVE AN INTERRUPT OR DO KEY.  IF THIS TERMINAL IS NOT IN RPA
; MODE THEN CONVERT THE INTERRUPT-DO SEQUENCE TO A CONTROL-C.
;
100$:
	BIT	#S1.PTH,(R5)		;;;READ-PASS-THRU?
	BNE	15$			;;;NE YES - PROCESS CHARACTER IS USUAL

	CMPB	#K.DO,(R0)		;;;DO KEY?
	BEQ	110$			;;;EQ YES - GO DEAL WITH IT
	INC	IDOFLG			;;;SET THE INTERRUPT SEEN FLAG
	BR	50$			;;;AND EXIT DISCARDING THE KEY

110$:	TST	IDOFLG			;;;WAS INTERRUPT PRESSED?
	BEQ	15$			;;;EQ NO - GO PROCESS DO AS NORMAL KEY
	CLR	IDOFLG			;;;CLEAR THE INTERRUPT FLAG
	MOV	#CH.CTC,R2		;;;CONVERT INTERRUPT-DO TO CTRL-C
	CALLR	ICHAR1			;;;PROCESSES IT

	.ENDC	;T$$IDO

15$:	CLR	IDOFLG			;;;CLEAR THE INTERRUPT FLAG

					;;;ASSUME THAT TYPE SPECIFIC DATA IS NEXT
					;;;ASSUME THAT IT IS WORD ALIGNED
	TST	(R0)+			;;;PASS OVER THE TYPE SPECIFIC INFO

;
; IF WE HAVE A MULTI CHARACTER INPUT SEQUENCE FOR DATA TYPE ZERO,
; (I.E. A CONTROL OR ESCAPE SEQUENCE), MAKE SURE THAT THERE IS ENOUGH
; ROOM IN THE TYPEAHEAD BUFFER FOR IT.  IF THERE IS NOT ENOUGH ROOM
; THEN DISCARD THE CHARACTERS AND ECHO A BELL.
;
	CMP	#1,R1			;;;ONLY ONE CHARACTER?
	BEQ	20$			;;;EQ YES - GO PRECESS IT.
	TST	DTYPE			;;;DATA TYPE 0?
	BNE	20$			;;;NE NO - GO PROCESS IT.

	.IF DF	T$$SPL

	MOV	#120000+U.TTBF,R3 	;;;GET TABUF

	.IFF	;T$$SPL

	MOV	U.TTAB-U.TSTA(R5),R3	;;;GET TABUF
	BEQ	20$			;;;NONE - GO PROCESS THE CHARACTER
	BIT	#1,R3			;;;SINGLE-CHAR. BUFFER?
	BNE	20$			;;;Y - GO PROCESS THE CHAR

	.ENDC	;T$$SPL

	MOVB	2(R3),R3		;;;GET CURRENT ACTIVE COUNT
	ADD	R1,R3			;;;ACTIVE COUNT INCLUDING NEW CHARS
	CMPB	R3,#T$$BFL-4		;;;TOO MANY CHARACTERS?
	BLOS	20$			;;;LOS NO - PROECSS THE CHARACTERS
	CALLR	BELL			;;;ECHO A BELL AND DISCARD THE CHAR

					;;;NOW COMES THE DATA
20$:	CLR	R2			;;;PREPARE R0 (STATUS MUST BE ZERO)
	BISB	(R0)+,R2		;;;GET A CHARACTER
	MOV	R0,-(SP)		;;;SAVE R0
	MOV	R1,-(SP)		;;;AND R1
	TST	DTYPE			;;;DATA TYPE 0?
	BEQ	30$			;;;IF EQ YES - HANDLE NORMAL TEXT
	CALL	IRSD1			;;;HANDLE SPECIAL DATA INPUT
	BR	40$			;;;GO GET THE NEXT ONE
30$:	CALL	ICHAR1			;;;DO COMMON INPUT PROC.
40$:	MOV	(SP)+,R1		;;;RESTORE R1
	MOV	(SP)+,R0		;;;AND R0
	SOB	R1,20$			;;;LOOP TILL DONE
50$:	RETURN				;AND EXIT

;
;+
; IRSD1 - INPUT CHARACTER PROCESSING FOR SPECIAL DATA
;
;	THIS ROUTINE IS CALLED FOR EACH SPECIAL DATA
;	INPUT CHARACTER.  THIS ROUTINE DOES BASICALLY
;	THE SAME THING AS ICHAR1 EXCEPT THAT
;	IT WILL PUT THE DATA IN A SPECIAL TYPEAHEAD
;	BUFFER UNLESS THERE IS AN IO.RSD OUTSTANDING.
;	IT IS SIMPLER AND PROBABLY SHORTER TO DO THIS
;	SEPARATLY HERE.
;
; INPUTS:
;	R2	BYTE
;	R5	POINTER TO U.TSTA
;	DTYPE	DATA PATH SPECIFIER  1 < DTYPE < 2*T.RSDN+1
;
; OUTPUTS:
;	ANY OF THE FOLLOWING ACTIONS IS TAKEN, DEPENDENT
;	ON LINE STATUS.
;
;	1. BYTE IS STORED IN THE APPROPRIATE DATA TYPE
;		SPECIFIC TYPEAHEAD BUFFER.
;
;	2. BYTE IS STORED IN THE INPUT BUFFER OF A
;		PENDING IO.RSD.
;
;	3. BYTE IS IGNORED IF THE TYPEAHEAD BUFFER IS FULL.
;		AT A LATER TIME SUPPORT COULD BE ADDED TO
;		RETURN AN ERROR FOR THIS SITUATION.
;
; REGISTERS ALTERED: R2,R3,R4
;-
;

IRSD1:	MOV	DTYPE,R3		;;;GET THE TABUF ADDRESS
	MOV	T.RSDT(R3),R3		;;;
	TSTB	2(R3)			;;;ANYTHING BUFFERED?
	BNE	100$			;;;Y - BUFFER THIS TO
	CALL	RSDPRC			;;;CAN WE PROCESS THIS BYTE?
	BCS	100$			;;;NO - GO STORE IT
	CALLR	ICHAR2			;;;GO PROCESS IT

; PUT THE CHARACTER INTO THE CORRECT TYPEAHEAD BUFFER

100$:	MOVB	(R3)+,R4		;;;GET OFFSET WHERE TO STORE
	INC	R3			;;;SKIP OVER 1 BYTE
	CMPB	(R3)+,(R3)+		;;;BUFFER FULL?
	BEQ	200$			;;;Y - IGNORE THE CHARACTER
	ADD	R3,R4			;;;MAKE POINTER INTO BUFFER
	MOVB	R2,(R4)			;;;STORE CHARACTER
	INC	-(R3)			;;;INCREMENT ACTIVE COUNTER
	INC	-(R3)			;;;UPDATE STORE POINTER
	CMPB	(R3),3(R3)		;;;WRAP-AROUND?
	BNE	200$			;;;N - JUMP
	CLRB	(R3)			;;;Y - SET POINTER AT START OF BUFFER
200$:	RETURN				;;;RETURN

;
;+
; RSDPRC - DETERMINE WHETHER A SPECIAL DATA BYTE CAN BE PROCESSED
;
; INPUT:
;	R5	POINTER TO U.TSTA
;
; OUTPUT:
;	IF CHARACTER CAN BE PROCESSED NOW:
;	R4	I/O PAKET ADDRESS
;	CC-C	0
;
;	IF CHARACTER CAN NOT BE PROCESSED NOW:
;	CC-C	1
;
; REGISTERS ALTERED: R4
;-
;

RSDPRC::BIT	#S1.DSI!S1.USI,(R5)	;;;INPUT PROCESSING DISABLED?
					;;;OR UNSOLICITED INP INPROGRESS?
	BNE	10$			;;;Y - CAN'T PROCESS NOW
	ASSUME	S1.IBY,200
	TSTB	(R5)			;;;INPUT BUSY?
	BPL	10$			;;;N - CAN'T PROCESS NOW

	MOV	U.TUX-U.TSTA(R5),R4	;;;GET UCBX
	BEQ	10$			;;;NONE - CAN'T PROCESS IT (COULD
					;;;HAPPEN FOR EXAMPLE WHEN CTRL-C
					;;;IS TYPED ON AN IDLE SLAVED TERM)
	ASSUME	U.TCI,0
	MOV	(R4),R4			;;;GET PACKET ADDRESS
	CMPB	#IO.RSD/400,I.FCN+1(R4)	;;;IS IT AN IO.RSD?
	BNE	10$			;;;N - CAN'T PROCESS NOW

	TST	(PC)+			;;;RETURN CARRY CLEAR, PROCESS IT
10$:	SEC				;;;RETURN CARRY SET
	RETURN				;;;RETURN

;
;+
; R$OUTD - OUTPUT DONE ROUTINE
;
; THIS ROUTINE IS CALLED IN SYSTEM STATE BY THE VIDEO TASK
; TO INFORM THE DRIVER THAT THE TASK IS DONE WITH THE CURRENT
; OUTPUT BUFFERS
;
; REGISTERS MODIFIED:
;		ALL
;-
;

	.IIF	DF,T$$SPL,.ERROR	;THIS CODE ASSUMES UCBX IN PRIMARY POOL
					;OR PRIVATE BUFFER POOL

R$OUTD::MTPS	#TTPRI			;LOCK OUT TERMINAL INTERRUPTS
	CLR	R4			;;;INDICATE THAT THIS IS CONTROLLER 0
	TTSET$	YC			;;;CALL TTSET SETTUP FOR POSSIBLE FORK
	CLR	T.OPKP			;;;CLEAR THE BUFFER POINTER
	BIC	#<TF.ABO!TF.SPN>,T.FLAG	;;;CLEAR THE ABORT AND SUSPEND BITS
	MOV	#.TTCT+U.TSTA,R5	;;;SETTUP FOR ODONE CALL
	MOV	U.TUX-U.TSTA(R5),R4	;;;GET UCBX ADDRESS
	MOV	T.OREM,U.TTOC(R4)	;;;RESTORE BYTES TRANSFERED COUNT
	CLR	U.TOC(R4)		;;;SHOW CURRENT BUFFER ALL DONE
	MOV	T.STAT,@U.TCO(R4)	;;;GET PACKET COMPLETION STATUS
	CALLR	ODONE			;;;FINISH OFF THE OUTPUT AND RETURN

;
;+
; CTICK - TIMER ROUTINE FOR CT VIDEO TASK
;
;	THIS ROUTINE IS CALLED ONCE EVERY CT$TIC TICKS TO
;	PROVIDE TIMER SERVICES FOR THE CT VIDEO TASK
;
; INPUTS:
;	NONE
;
; OUTPUTS:
;	THE THREE CT TIMERS ARE CHECKED AND THE VIDEO TASK
;	IS NOTIFIED IF THEY RUN OUT
;-
;

CTICK::	CALL	MAPD			;SETTUP TERMINAL DRIVER MAPPING
	CLR	-(SP)			;GET A WORD ON THE STACK

	TST	T.BTMR			;BLINK TIMER ACTIVE?
	BEQ	10$			;IF EQ NO - TRY THE NEXT TIMER
	DEC	T.BTMR			;DECREMENT THE TIMER
	BNE	10$			;IF NE, NOT TIMED OUT YET
	BIS	#TF.BTM,(SP)		;SET THE BLINK TIMER FLAG

10$:	TST	T.CTMR			;CURSOR TIMER ACTIVE?
	BEQ	20$			;IF EQ NO - TRY THE NEXT TIMER
	DEC	T.CTMR			;DECREMENT THE TIMER
	BNE	20$			;IF NE, NOT TIMED OUT YET
	BIS	#TF.CTM,(SP)		;SET THE CURSOR TIMER FLAG

; T.STMR IS MAINTAINED IN SECONDS, NOT TICS

20$:	TST	T.STMR			;SCREEN BLANK TIMER ACTIVE?
	BEQ	30$			;IF EQ NO - FINISH UP
	DEC	STIMER			;SCREEN TICS COUNTER FINISHED?
	BPL	30$			;IF PL NO - FINISH UP
	MOV	$TKPS,STIMER		;RESET SCREEN TICS COUNTER
	DEC	T.STMR			;DECREMENT THE SCREEN TIMER
	BNE	30$			;IF NE, NOT TIMED OUT YET
	BIS	#TF.STM,(SP)		;SET THE SCREEN BLANK TIMER FLG	

30$:	BIS	(SP),T.FLAG		;SET ANY BITS IN THE FLAG WORD
	TST	(SP)+			;ANY TIMERS GO OFF?
	BEQ	CTQUEK			;IF EQ NO - REQUEUE THE CLOCK BLOCK
	CALL	REQEST			;REQUEST THE TASK
	ASSUME	.,CTQUEK		;AND REQUEUE THE CLOCK BLOCK


;
;+
; CTQUEK - QUEUE THE CLOCK BLOCK
;-
;

CTQUEK::MOV	#$CTCB,R0		;GET THE CLOCK BLOCK
	CLR	R1			;CLEAR THE HIGH ORDER DELTA TIME
	MOV	#CT$TIC,R2		;SET THE LOW ORDER DELTA
	MOV	#C.SYST,R4		;TYPE = SYSTEM SUBROUTINE
	CALLR	$CLINS			;INSERT IN CLOCK QUEUE AND RETURN

;
;+
; UNUSED ENTRY POINTS, SHOULD NEVER BE CALLED
;-
;
$YCOUT::				;OUTPUT INTERRUPT SERVICE ROUTINE
$YCINP::				;INPUT INTERRUPT SERVICE ROUTINE
YCMTIM::CRASH				;MODEM TIMER


	.ENDC	;B$$MAP

	.END